﻿using System.Linq.Expressions;

namespace Lanbt.Core.Utility.Extent
{
    /// <summary>
    /// Expression 扩展方法
    /// </summary>
    public static partial class Extensions
    {

        /// <summary>
        /// 初始化
        /// </summary>
        /// <typeparam name="T">泛型类型</typeparam>
        /// <param name="first">现有条件</param>
        /// <returns></returns>
        public static Expression<Func<T, bool>> Load<T>()
        {
            Expression<Func<T, bool>> where = q => 1 == 1;
            return where;
        }

        /// <summary>
        /// 合并条件
        /// </summary>
        /// <typeparam name="T">泛型类型</typeparam>
        /// <param name="first">现有条件</param>
        /// <param name="second">添加条件</param>
        /// <returns></returns>
        public static Expression<Func<T, bool>> And<T>(
            this Expression<Func<T, bool>> first,
            Expression<Func<T, bool>> second)
        {
            return first.AndAlso<T>(second, Expression.AndAlso);
        }

        /// <summary>
        /// 添加或条件
        /// </summary>
        /// <typeparam name="T">泛型类型</typeparam>
        /// <param name="first">现有条件</param>
        /// <param name="second">添加条件</param>
        /// <returns></returns>
        public static Expression<Func<T, bool>> Or<T>(
            this Expression<Func<T, bool>> first,
            Expression<Func<T, bool>> second)
        {
            return first.AndAlso<T>(second, Expression.OrElse);
        }

        private static Expression<Func<T, bool>> AndAlso<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2, Func<Expression, Expression, BinaryExpression> func)
        {
            var parameter = Expression.Parameter(typeof(T));
            //var parameter2 = Expression.Parameter(typeof(T));
            var ddd = expr1.Parameters;
            var leftVisitor = new ReplaceExpressionVisitor(expr1.Parameters[0], parameter);
            var left = leftVisitor.Visit(expr1.Body);

            var rightVisitor = new ReplaceExpressionVisitor(expr2.Parameters[0], parameter);//不是用.Parameters[0]结果是不对的
            var right = rightVisitor.Visit(expr2.Body);

            return Expression.Lambda<Func<T, bool>>(func(left, right), parameter);
            ///return Expression.Lambda(func(left, right), parameter);
        }

        private class ReplaceExpressionVisitor
            : ExpressionVisitor
        {
            private readonly Expression _oldValue;
            private readonly Expression _newValue;

            public ReplaceExpressionVisitor(Expression oldValue, Expression newValue)
            {
                _oldValue = oldValue;
                _newValue = newValue;
            }

            public override Expression Visit(Expression node)
            {
                if (node == _oldValue)
                    return _newValue;
                return base.Visit(node);
            }
        }
    }
}
